home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 1 / BBS in a box - Trilogy I.iso / Files / Publish / Photoshop / Plug-in Modules / Code / PIUtilities.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-26  |  6.9 KB  |  203 lines  |  [TEXT/MPS ]
  1. /* Plug-in module utility routines */
  2.  
  3. /* Copyright 1993 by Adobe Systems, Inc.  All rights reserved. */
  4.  
  5. /* The routines in this module provide a collection of utilities for accessing
  6.    the plug-in callback procedures and performing other useful tasks within
  7.    plug-ins. */
  8.  
  9. #ifndef __PIUtilities__
  10. #define __PIUtilities__
  11.  
  12. #include <StdDef.h>
  13. #include <Types.h>
  14.  
  15. #include "PIGeneral.h"
  16.  
  17. /*****************************************************************************/
  18.  
  19. /* The following routines provide shells around the buffer procs routines.
  20.    These routines allow us to allocate buffers from Photoshop's memory
  21.    without first telling Photoshop about it in the bufferSpace or maxSpace
  22.    parameter in the interface record.  This can be useful when we need
  23.    different sized buffers at different times. */
  24.  
  25. /* Are the buffer procs even available?  If not, the plug-in will have to
  26.    put up a warning dialog to indicate that it requires Photoshop 2.5 or
  27.    will have to work around this using the old memory management techniques
  28.    documented in earlier versions of the plug-in kit.  tooNew is set if the
  29.    procs version is newer than the plug-in.  The buffer procs version number
  30.    is unlikely to change, but it is wise to test it anyway.  If tooNew is
  31.    null, it will be ignored. */
  32.  
  33. Boolean HostBufferProcsAvailable (BufferProcs *procs, Boolean *tooNew);
  34.  
  35. /* The following dialog takes care of putting up the warning if the appropriate
  36.    version of the buffer procs is not available. */
  37.  
  38. Boolean WarnHostBufferProcsAvailable (BufferProcs *procs);
  39.  
  40. /* How much space is available for buffers?  This space may be fragmented. */
  41.  
  42. int32 HostBufferSpace (BufferProcs *procs); 
  43.  
  44. /* Allocate a buffer of the appropriate size setting bufferID to the ID
  45.    for the buffer.  If an error occurs, the error code will be returned
  46.    and bufferID will be set to zero. */
  47.  
  48. OSErr HostAllocateBuffer (BufferProcs *procs, int32 size, BufferID *bufferID);
  49.  
  50. /* Free the buffer with the given ID. */
  51.  
  52. void HostFreeBuffer (BufferProcs *procs, BufferID bufferID);
  53.  
  54. /* Lock the buffer and return a pointer to its contents. */
  55.  
  56. Ptr HostLockBuffer (BufferProcs *procs, BufferID bufferID, Boolean moveHigh);
  57.  
  58. /* Unlock the buffer.  Lock and unlock calls manipulate a counter, so they
  59.    must balance perfectly. */
  60.  
  61. void HostUnlockBuffer (BufferProcs *procs, BufferID bufferID);
  62.  
  63. /* The following routine allocates a buffer which is as tall as possible.  It
  64.    takes as parameters, the desired rowBytes, the minimum height, the
  65.    maximum height, and the fraction of the available buffer space to use
  66.    expressed as 1/numBuffers.  It sets the actual height and bufferID
  67.    parameters if successful. */
  68.  
  69. OSErr HostAllocateStripBuffer (BufferProcs *procs,
  70.                                int32 rowBytes,
  71.                                int16 minHeight,
  72.                                int16 maxHeight,
  73.                                int16 numBuffers,
  74.                                int16 *actualHeight,
  75.                                BufferID *bufferID);
  76.  
  77. /*****************************************************************************/
  78.  
  79. /* The following macros assume that gStuff is defined somewhere as a pointer
  80.    to the current interface record. */
  81.  
  82. #define BufferProcsAvailable(tooNew) \
  83.     HostBufferProcsAvailable (gStuff->bufferProcs, tooNew)
  84.  
  85. #define WarnBufferProcsAvailable() \
  86.     WarnHostBufferProcsAvailable (gStuff->bufferProcs)
  87.  
  88. #define BufferSpace() HostBufferSpace (gStuff->bufferProcs)
  89.  
  90. #define AllocateBuffer(size,bufferID) \
  91.     HostAllocateBuffer (gStuff->bufferProcs, size, bufferID)
  92.  
  93. #define FreeBuffer(bufferID) \
  94.     HostFreeBuffer (gStuff->bufferProcs, bufferID)
  95.  
  96. #define LockBuffer(bufferID,moveHigh) \
  97.     HostLockBuffer (gStuff->bufferProcs, bufferID, moveHigh)
  98.  
  99. #define UnlockBuffer(bufferID) \
  100.     HostUnlockBuffer (gStuff->bufferProcs, bufferID)
  101.  
  102. #define AllocateStripBuffer(rowBytes,minHeight,maxHeight,numBuffers,actualHeight,bufferID) \
  103.     HostAllocateStripBuffer (gStuff->bufferProcs,\
  104.                              rowBytes,\
  105.                              minHeight,\
  106.                              maxHeight,\
  107.                              numBuffers,\
  108.                              actualHeight,\
  109.                              bufferID)
  110.  
  111. /*****************************************************************************/
  112.  
  113. /* Similarly assuming gStuff to be defined, we define macros for testing
  114.    for abort and for updating the progress bar. */
  115.  
  116. #define TestAbort() ((*gStuff->abortProc) ())
  117.  
  118. #define UpdateProgress(done,total) ((*gStuff->progressProc) (done, total))
  119.  
  120. /*****************************************************************************/
  121.  
  122. /* Here is a corresponding set of routines and macros for the pseudo-resource
  123.    callbacks. */
  124.  
  125. Boolean HostResourceProcsAvailable (ResourceProcs *procs, Boolean *tooNew);
  126.  
  127. Boolean WarnHostResourceProcsAvailable (ResourceProcs *procs);
  128.  
  129. int16 HostCountPIResources (ResourceProcs *procs, ResType type);
  130.  
  131. Handle HostGetPIResource (ResourceProcs *procs, ResType type, int16 index);
  132.  
  133. void HostDeletePIResource (ResourceProcs *procs, ResType type, int16 index);
  134.  
  135. OSErr HostAddPIResource (ResourceProcs *procs, ResType type, Handle data);
  136.  
  137. #define ResourceProcsAvailable(tooNew)                                        \
  138.     HostResourceProcsAvailable (gStuff->resourceProcs, tooNew)
  139.     
  140. #define WarnResourceProcsAvailable()                                        \
  141.     WarnHostResourceProcsAvailable (gStuff->resourceProcs)
  142.     
  143. #define CountPIResources(type)                                                \
  144.     HostCountPIResources (gStuff->resourceProcs, type)
  145.     
  146. #define GetPIResource(type,index)                                            \
  147.     HostGetPIResource (gStuff->resourceProcs, type, index)
  148.     
  149. #define DeletePIResource(type,index)                                        \
  150.     HostDeletePIResource (gStuff->resourceProcs, type, index)
  151.     
  152. #define AddPIResource(type,data)                                            \
  153.     HostAddPIResource (gStuff->resourceProcs, type, data)
  154.  
  155. /*****************************************************************************/
  156.  
  157. /* And a set for the handle routines. */
  158.  
  159. Boolean HostHandleProcsAvailable (HandleProcs *procs, Boolean *tooNew);
  160.  
  161. Boolean WarnHostHandleProcsAvailable (HandleProcs *procs);
  162.  
  163. Handle HostNewHandle (HandleProcs *procs, int32 size);
  164.  
  165. void HostDisposeHandle (HandleProcs *procs, Handle h);
  166.  
  167. int32 HostGetHandleSize (HandleProcs *procs, Handle h);
  168.  
  169. OSErr HostSetHandleSize (HandleProcs *procs, Handle h, int32 newSize);
  170.  
  171. Ptr HostLockHandle (HandleProcs *procs, Handle h, Boolean moveHigh);
  172.  
  173. void HostUnlockHandle (HandleProcs *procs, Handle h);
  174.  
  175.  
  176. #define HandleProcsAvailable(tooNew)                                        \
  177.     HostHandleProcsAvailable (gStuff->handleProcs, tooNew)
  178.     
  179. #define WarnHandleProcsAvailable()                                            \
  180.     WarnHandleProcsAvailable (gStuff->handleProcs);
  181.     
  182. #define PINewHandle(size)                                                    \
  183.     HostNewHandle (gStuff->handleProcs, size)
  184.     
  185. #define PIDisposeHandle(h)                                                    \
  186.     HostDisposeHandle (gStuff->handleProcs, h)
  187.     
  188. #define PIGetHandleSize(h)                                                    \
  189.     HostGetHandleSize (gStuff->handleProcs, h)
  190.     
  191. #define PISetHandleSize(h,size)                                                \
  192.     HostSetHandleSize (gStuff->handleProcs, h, size)
  193.     
  194. #define PILockHandle(h,moveHigh)                                            \
  195.     HostLockHandle (gStuff->handleProcs, h, moveHigh)
  196.     
  197. #define PIUnlockHandle(h)                                                    \
  198.     HostUnlockHandle (gStuff->handleProcs, h)
  199.  
  200. /*****************************************************************************/
  201.  
  202. #endif
  203.